package com.cobra.ldtp;
/*
LDTP v2 java client.

@author: Nagappan Alagappan <nagappan@gmail.com>
@copyright: Copyright (c) 2009-13 Nagappan Alagappan
@license: LGPL

http://ldtp.freedesktop.org

This file may be distributed and/or modified under the terms of the GNU Lesser General
Public License version 2 as published by the Free Software Foundation. This file
is distributed without any warranty; without even the implied warranty of 
merchantability or fitness for a particular purpose.

See 'COPYING' in the source distribution for more information.

Headers in this file shall remain intact.
 */
// This file depends on apache jar files:
// http://mirror.cc.columbia.edu/pub/software/apache//commons/codec/binaries/commons-codec-1.6-bin.zip
// http://www.apache.org/dyn/closer.cgi/ws/xmlrpc/
// Ran the test in Ubuntu 11.04 as
// export CLASSPATH=.:commons-codec-1.6.jar:ws-commons-utils-1.0.2.jar:xmlrpc-client-3.1.3.jar:xmlrpc-common-3.1.3.jar
// make
// make doc
// java Ldtp
// Ran the test in Windows 7 SP1 like: (Adjusted the code accordingly for Windows, as I need to maniuplate with Notepad)
// java -cp xmlrpc-client-3.1.3.jar;xmlrpc-common-3.1.3.jar;ws-commons-util-1.0.2.jar;commons-codec-1.6.jar;. Ldtp
import java.net.URL;
import java.util.Arrays;
import java.io.FileOutputStream;
import java.lang.ProcessBuilder;
import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
import org.apache.xmlrpc.client.XmlRpcClient;
import org.apache.commons.codec.binary.Base64;
import org.apache.xmlrpc.client.XmlRpcClientConfigImpl;

/**
 * Ldtp class is a wrapper to the Ldtp GUI automation library, works on both Windows and Linux environment
 */
public class Ldtp {
	Process p = null;
	boolean debug = false;
	String windowName = null;
	String serverAddr = null;
	String serverPort = null;
	ProcessBuilder pb;
	Boolean windowsEnv = false;
	XmlRpcClient client = null;
	PollEvents pollEvents = null;
	XmlRpcClientConfigImpl config = null;
	public Log log = LogFactory.getLog("");
	/**
	 * connectToServer (private), which connects to the running instance of LDTP server
	 */
	private void connectToServer() {
		if (serverAddr == null)
			serverAddr = System.getenv("LDTP_SERVER_ADDR");
		if (serverAddr == null)
			serverAddr = "localhost";
		if (serverPort == null)
			serverPort = System.getenv("LDTP_SERVER_PORT");
		if (serverPort == null)
			serverPort = "4118";
		if (System.getenv("LDTP_DEBUG") != null)
			debug = true;
		String tmpEnv = System.getenv("LDTP_WINDOWS");
		if (tmpEnv != null)
			windowsEnv = true;
		else {
			tmpEnv = System.getenv("LDTP_LINUX");
			if (tmpEnv != null)
				windowsEnv = false;
			else {
				String os = System.getProperty("os.name").toLowerCase();
				if (os.indexOf("win") >= 0)
					windowsEnv = true;
			}
		}
		config = new XmlRpcClientConfigImpl();
		String url = String.format("http://%s:%s/RPC2", serverAddr, serverPort);
		try {
			config.setServerURL(new URL(url));
		} catch (java.net.MalformedURLException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
		client = new XmlRpcClient();
		client.setConfig(config);
		Boolean alive = isAlive();
		if (!alive) {
			if (serverAddr.contains("localhost"))
				launchLdtpProcess();
			// Verify we are able to connect after launching the server
			alive = isAlive();
			if (!alive)
				throw new LdtpExecutionError("Unable to connect to server");
		}
	}
	/**
	 * isAlive (private) Check the connection to LDTP server
	 */
	private Boolean isAlive() {
		Boolean isAlive = false;
		Object[] params = null;
		try {
			isAlive = (Boolean)client.execute("isalive", params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			// Ignore any exception
		} catch (Exception ex) {
			// Ignore any exception
		}
		return isAlive;
	}
	/**
	 * launchLdtpProcess (private) Launch LDTP executable
	 */
	private void launchLdtpProcess() {
		if (windowsEnv)
			// Launch Windows LDTP
			pb = new ProcessBuilder("CobraWinLDTP.exe");
		else
			// Launch Linux LDTP
			pb = new ProcessBuilder("ldtp");
		try {
			// Start the process
			p = pb.start();
			// Add a hook to kill the process
			// started by current Ldtp instance
			Runtime.getRuntime().addShutdownHook(new Thread() {
				public void run() {
					terminateLdtpProcess();
				}
			});
		} catch (java.io.IOException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
		try {
			// Sleep 5 seconds
			Thread.sleep(5000);
		} catch (java.lang.InterruptedException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * terminateLdtpProcess (private) Terminate LDTP executable started by this instance
	 */
	private void terminateLdtpProcess() {
		if (p != null) {
			// Kill LDTP executable
			p.destroy();
		}
		if (pollEvents != null)
			pollEvents.pollServer = false;
	}
	/**
	 * Ldtp
	 *
	 * @param windowName Window to be manipulated
	 */
	public Ldtp(String windowName) {
		this(windowName, null);
	}
	/**
	 * Ldtp
	 *
	 * @param windowName Window to be manipulated
	 * @param serverAddr Server address to connect to
	 */
	public Ldtp(String windowName, String serverAddr) {
		this(windowName, serverAddr, null);
	}
	/**
	 * Ldtp
	 *
	 * @param windowName Window to be manipulated
	 * @param serverAddr Server address to connect to
	 * @param serverPort Server port to connect to
	 */
	public Ldtp(String windowName, String serverAddr, String serverPort) {
		if (windowName == null || windowName == "") {
			throw new LdtpExecutionError("Window name missing");
		}
		this.serverAddr = serverAddr;
		this.serverPort = serverPort;
		this.windowName = windowName;
		connectToServer();
		pollEvents = new PollEvents(this);
		pollEvents.start();
	}
	/**
	 * setWindowName Change window name
	 *
	 * @param windowName Window to be manipulated
	 */
	public void setWindowName(String windowName) {
		if (windowName == null || windowName == "") {
			throw new LdtpExecutionError("Window name missing");
		}
		this.windowName = windowName;
	}
	/**
	 * getWindowName Get currently set window name
	 */
	public String getWindowName() {
		return windowName;
	}
	/**
	 * getJavaObjectList Execute XML-RPC command and get the output as Java Object array
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as Object array
	 */
	private Object[] getJavaObjectList(String cmd, Object[] params) {
		try {
			return (Object[])client.execute(cmd, params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * verifyAction (private) Verification API
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as 1 on success, 0 on failure
	 */
	private Integer verifyAction(String cmd, Object[] params) {
		try {
			return doAction(cmd, params);
		} catch (Exception ex) {
			return 0;
		}
	}
	/**
	 * verifyAction (private) Action API
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as 1 on success, LdtpExecutionError exception on failure
	 */
	private Integer doAction(String cmd, Object[] params) {
		try {
			return (Integer)client.execute(cmd, params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * getString (private) get String value as output
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as String value on success
	 * @throws LdtpExecutionError exception on failure
	 */
	private String getString(String cmd, Object[] params) {
		try {
			return (String)client.execute(cmd, params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * getInt (private) get Integer value as output
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as Integer value on success
	 * @throws LdtpExecutionError exception on failure
	 */
	private Integer getInt(String cmd, Object[] params) {
		try {
			return (Integer)client.execute(cmd, params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * getDouble (private) get Double value as output
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as Double value on success
	 * @throws LdtpExecutionError exception on failure
	 */
	private Double getDouble(String cmd, Object[] params) {
		try {
			return (Double)client.execute(cmd, params);
		} catch (org.apache.xmlrpc.XmlRpcException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
	}
	/**
	 * getDoubleList (private) Execute XML-RPC command and get the output as Double array
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as Object array
	 */
	private Double[] getDoubleList(String cmd, Object[] params) {
		Double[] result = null;
		Object[] o = getJavaObjectList(cmd, params);
		result = Arrays.copyOf(o, o.length, Double[].class);
		return result;
	}
	/**
	 * getStringList (private) Execute XML-RPC command and get the output as String array
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as String array
	 */
	private String[] getStringList(String cmd, Object[] params) {
		String[] result = null;
		Object[] o = getJavaObjectList(cmd, params);
		result = Arrays.copyOf(o, o.length, String[].class);
		return result;
	}
	/**
	 * getIntList (private) Execute XML-RPC command and get the output as Integer array
	 *
	 * @param cmd Command to be executed on the server side
	 * @param params Parameters to be passed to the command
	 * @return Return the output as Integer array
	 */
	private Integer[] getIntList(String cmd, Object[] params) {
		Integer[] result = null;
		Object[] o = getJavaObjectList(cmd, params);
		result = Arrays.copyOf(o, o.length, Integer[].class);
		return result;
	}
	// General
	/**
	 * getWindowList Get currently open window list
	 *
	 * @return Return the output as String array
	 */
	public String[] getWindowList() throws LdtpExecutionError {
		return getStringList("getwindowlist", null);
	}
	/**
	 * getAppList Get currently open application list
	 *
	 * @return Return the output as String array
	 */
	public String[] getAppList() throws LdtpExecutionError {
		return getStringList("getapplist", null);
	}
	/**
	 * getObjectList Get current windows object list
	 *
	 * @return Return the output as String array
	 */
	public String[] getObjectList() throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return getStringList("getobjectlist", params);
	}
	/**
	 * getObjectInfo Get current object info
	 *
	 * @param objName Object name
	 * @return Return the properties of the current object as String array
	 */
	public String[] getObjectInfo(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getStringList("getobjectinfo", params);
	}
	/**
	 * getAccessKey Get access key
	 *
	 * @param objName Object name
	 * @return Return the access key as String
	 */
	public String getAccessKey(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getString("getaccesskey", params);
	}
	/**
	 * getObjectProperty Get current object property
	 *
	 * @param objName Object name
	 * @param property Property of the children like class, label, label_by, child_index
	 * @return Return the property as String
	 */
	public String getObjectProperty(String objName, String property) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, property};
		return getString("getobjectproperty", params);
	}
	/**
	 * getChild Get children matching child name
	 *
	 * @param childName Child name
	 * @return Return the children as String array
	 */
	public String[] getChild(String childName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, childName};
		return getStringList("getchild", params);
	}
	/**
	 * getChild Get children matching child name and role
	 *
	 * @param childName Child name
	 * @param role object role type
	 * @return Return the children as String array
	 */
	public String[] getChild(String childName, String role) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, childName, role};
		return getStringList("getchild", params);
	}
	/**
	 * getChild Get children matching child name, role, property
	 *
	 * @param childName Child name
	 * @param role object role type
	 * @param property property of child
	 * @return Return the children as String array
	 */
	public String[] getChild(String childName, String role, String property) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, childName, role, property};
		return getStringList("getchild", params);
	}
	/**
	 * getObjectSize Get object size
	 *
	 * @param objName Object name
	 * @return Return the size as Integer list
	 */
	public Integer[] getObjectSize(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getIntList("getobjectsize", params);
	}
	/**
	 * getWindowSize Get window size
	 *
	 * @return Return the size as Integer list
	 */
	public Integer[] getWindowSize() throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return getIntList("getwindowsize", params);
	}
	/**
	 * reMap Re-Map current window
	 *
	 * @return Return the 1 on success
	 * @throws LdtpExecutionError exception on failure
	 */
	public int reMap() {
		Object[] params = new Object[]{windowName};
		return verifyAction("remap", params);
	}
	/**
	 * waitTime Sleep for 5 seconds
	 *
	 * @return Return the 1 on success
	 * @throws LdtpExecutionError exception on failure
	 */
	public int waitTime() {
		return waitTime(5);
	}
	/**
	 * waitTime Sleep for given seconds
	 *
	 * @param timeout Sleep for timeout seconds
	 * @return Return the 1 on success
	 * @throws LdtpExecutionError exception on failure
	 */
	public int waitTime(int timeout) {
		Object[] params = new Object[]{timeout};
		return doAction("wait", params);
	}
	/**
	 * objectTimeOut Change default object time out
	 *
	 * @param timeout Change default object time out search in seconds
	 * @return Return the 1 on success
	 * @throws LdtpExecutionError exception on failure
	 */
	public int objectTimeOut(int timeout) {
		Object[] params = new Object[]{timeout};
		return doAction("objecttimeout", params);
	}
	/**
	 * guiTimeOut Change default window time out search
	 *
	 * @param timeout Change default window time out search in seconds
	 * @return Return the 1 on success
	 * @throws LdtpExecutionError exception on failure
	 */
	public int guiTimeOut(int timeout) {
		Object[] params = new Object[]{timeout};
		return doAction("guitimeout", params);
	}
	/**
	 * getObjectNameAtCoords Get object name at co-ordinates without any delay
	 *
	 * @return Return String array of possible window name and object name
	 */
	public String[] getObjectNameAtCoords() {
		return getObjectNameAtCoords(0.0);
	}
	/**
	 * getObjectNameAtCoords Get object name at co-ordinates
	 *
	 * @param waitTime wait for the given time and then try to find the window and object name
	 * @return Return String array of possible window name and object name
	 */
	public String[] getObjectNameAtCoords(double waitTime) {
		Object[] params = new Object[]{waitTime};
		return getStringList("getobjectnameatcoords", params);
	}
	/**
	 * guiExist Verifies whether the current window exist or not
	 *
	 * @return Return 1 on success, 0 on failure
	 */
	public int guiExist() {
		return guiExist("");
	}
	/**
	 * guiExist Verifies whether the current window and given object exist or not
	 *
	 * @param objName Object name to look
	 * @return Return 1 on success, 0 on failure
	 */
	public int guiExist(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("guiexist", params);
	}
	/**
	 * waitTillGuiExist Wait for the current window for 30 seconds
	 *
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist() {
		return waitTillGuiExist("", 30, "");
	}
	/**
	 * waitTillGuiExist Wait for the current window and object name for 30 seconds
	 *
	 * @param objName Object name to look
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist(String objName) {
		return waitTillGuiExist(objName, 30, "");
	}
	/**
	 * waitTillGuiExist Wait for the current window and object name for given seconds
	 *
	 * @param objName Object name to look
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist(String objName, int guiTimeOut) {
		return waitTillGuiExist(objName, guiTimeOut, "");
	}
	/**
	 * waitTillGuiExist Wait for the current window for given seconds
	 *
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist(int guiTimeOut) {
		return waitTillGuiExist("", guiTimeOut, "");
	}
	/**
	 * waitTillGuiExist Wait for the current window, state for given seconds
	 *
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @param state Wait for the state
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist(int guiTimeOut, String state) {
		return waitTillGuiExist("", guiTimeOut, state);
	}
	/**
	 * waitTillGuiExist Wait for the current window, object name, state for given seconds
	 *
	 * @param objName Object name to look
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @param state Wait for the state
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiExist(String objName, int guiTimeOut, String state) {
		Object[] params = new Object[]{windowName, objName, guiTimeOut, state};
		return verifyAction("waittillguiexist", params);
	}
	/**
	 * waitTillGuiNotExist Wait for the current window to disappear for 30 seconds
	 *
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist() {
		return waitTillGuiNotExist("", 30, "");
	}
	/**
	 * waitTillGuiNotExist Wait for the current window, object name to disappear for 30 seconds
	 *
	 * @param objName Object name to look
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist(String objName) {
		return waitTillGuiNotExist(objName, 30, "");
	}
	/**
	 * waitTillGuiNotExist Wait for the current window, object name to disappear for given seconds
	 *
	 * @param objName Object name to look
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist(String objName, int guiTimeOut) {
		return waitTillGuiNotExist(objName, guiTimeOut, "");
	}
	/**
	 * waitTillGuiNotExist Wait for the current window to disappear for given seconds
	 *
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist(int guiTimeOut) {
		return waitTillGuiNotExist("", guiTimeOut, "");
	}
	/**
	 * waitTillGuiNotExist Wait for the current window, state to disapper for given seconds
	 *
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @param state Wait for the state
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist(int guiTimeOut, String state) {
		return waitTillGuiExist("", guiTimeOut, state);
	}
	/**
	 * waitTillGuiNotExist Wait for the current window, object name, state to disappear for given seconds
	 *
	 * @param objName Object name to look
	 * @param guiTimeOut Wait for the given time rather than default 30 seconds
	 * @param state Wait for the state
	 * @return Return 1 on success, 0 on failure
	 */
	public int waitTillGuiNotExist(String objName, int guiTimeOut, String state) {
		Object[] params = new Object[]{windowName, objName, guiTimeOut, state};
		return verifyAction("waittillguinotexist", params);
	}
	/**
	 * objectExist Verifies whether the window and object exist
	 *
	 * @param objName Object name to look
	 * @return Return 1 on success, 0 on failure
	 */
	public int objectExist(String objName) {
		return guiExist(objName);
	}
	/**
	 * delayCmdExec Delay each actions by given seconds
	 *
	 * @param delay Delay the command execution
	 * @return Return 1 on success, 0 on failure
	 */
	public int delayCmdExec(int delay) {
		Object[] params = new Object[]{delay};
		return verifyAction("delaycmdexec", params);
	}
	/**
	 * launchApp Launch application
	 *
	 * @param cmd Executable to launch
	 * @return Return pid of the launched process on success
	 * @throws LdtpExecutionError on failure
	 */
	public int launchApp(String cmd) {
		String[] args = {};
		return launchApp(cmd, args, 0, 1, "C");
	}
	/**
	 * launchApp Launch application
	 *
	 * @param cmd Executable to launch
	 * @param args String array argument to the executable
	 * @return Return pid of the launched process on success
	 * @throws LdtpExecutionError on failure
	 */
	public int launchApp(String cmd, String[] args) {
		return launchApp(cmd, args, 0, 1, "C");
	}
	/**
	 * launchApp Launch application
	 *
	 * @param cmd Executable to launch
	 * @param args String array argument to the executable
	 * @param delay Wait given number of seconds after the command executed successfully
	 * @return Return pid of the launched process on success
	 * @throws LdtpExecutionError on failure
	 */
	public int launchApp(String cmd, String[] args, int delay) {
		return launchApp(cmd, args, delay, 1, "C");
	}
	/**
	 * launchApp Launch application
	 *
	 * @param cmd Executable to launch
	 * @param args String array argument to the executable
	 * @param delay Wait given number of seconds after the command executed successfully
	 * @param env Gnome accessibility to be set or not
	 * @return Return pid of the launched process on success
	 * @throws LdtpExecutionError on failure
	 */
	public int launchApp(String cmd, String[] args, int delay, int env) {
		return launchApp(cmd, args, delay, env, "C");
	}
	/**
	 * launchApp Launch application
	 *
	 * @param cmd Executable to launch
	 * @param args String array argument to the executable
	 * @param delay Wait given number of seconds after the command executed successfully
	 * @param env Gnome accessibility to be set or not
	 * @param lang Locale language to be used
	 * @return Return pid of the launched process on success
	 * @throws LdtpExecutionError on failure
	 */
	public int launchApp(String cmd, String[] args, int delay, int env, String lang) {
		Object[] params = new Object[]{cmd, args, delay, env, lang};
		return doAction("launchapp", params);
	}
	/**
	 * pollEvents (private) Poll for events
	 *
	 * @return Return event generated on the server
	 */
	String pollEvents() {
		return getString("poll_events", null);
	}
	/**
	 * getLastLog Gets last log from server
	 *
	 * @return Return log from server
	 */
	public String getLastLog() {
		return getString("getlastlog", null);
	}
	/**
	 * startProcessMonitor Starts process monitor
	 *
	 * @param processName Process to be monitored
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int startProcessMonitor(String processName) throws LdtpExecutionError {
		Object[] params = new Object[]{processName};
		return doAction("startprocessmonitor", params);
	}
	/**
	 * stopProcessMonitor Stop process monitor
	 *
	 * @param processName Stop monitoring the process
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int stopProcessMonitor(String processName, int interval) throws LdtpExecutionError {
		Object[] params = new Object[]{processName, interval};
		return doAction("stopprocessmonitor", params);
	}
	/**
	 * getCpuStat Get CPU stat
	 *
	 * @param processName Get CPU stat of process
	 * @return Return Double list of CPU stat on success, empty list on failure
	 */
	public Double[] getCpuStat(String processName) {
		Object[] params = new Object[]{processName};
		return getDoubleList("getcpustat", params);
	}
	/**
	 * getMemoryStat Get memory stat
	 *
	 * @param processName Get memory stat of process
	 * @return Return Integer list of memory stat on success, empty list on failure
	 */
	public Integer[] getMemoryStat(String processName) {
		Object[] params = new Object[]{processName};
		return getIntList("getmemorystat", params);
	}
	/**
	 * windowUpTime Get uptime of window
	 *
	 * @return Return DateTime on success
	 * @throws LdtpExecutionError on failure
	 */
	// FIXME: Return DateTime, rather than int
	public int windowUpTime() throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("windowuptime", params);
	}
	/**
	 * onWindowCreate On new window opened call the given method
	 *
	 * @param obj Class instance
	 * @param isStatic Passed method name is static ?
	 * @param methodName Method name to be called from the class
	 * @param args Optional arguments to the callback method
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int onWindowCreate(Object obj, final boolean isStatic, final String methodName, final Object... args) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		pollEvents.addCallbacks("onwindowcreate-" + windowName, obj, isStatic, methodName, args);
		return doAction("onwindowcreate", params);
	}
	/**
	 * removeCallback Remove window name from callback method
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int removeCallback() throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		pollEvents.removeCallbacks("onwindowcreate-" + windowName);
		return doAction("removecallback", params);
	}
	/**
	 * registerEvent Register event to watch for
	 *
	 * @param eventName Event name to watch for
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int registerEvent(String eventName) throws LdtpExecutionError {
		Object[] params = new Object[]{eventName};
		return doAction("registerevent", params);
	}
	/**
	 * deRegisterEvent De-Register event to watch for
	 *
	 * @param eventName Don't watch the event name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int deRegisterEvent(String eventName) throws LdtpExecutionError {
		Object[] params = new Object[]{eventName};
		return doAction("deRegisterevent", params);
	}
	/**
	 * registerKbEvent register Keyboard event to watch for
	 *
	 * @param keys Watch the keys
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int registerKbEvent(String keys) throws LdtpExecutionError {
		Object[] params = new Object[]{keys};
		return doAction("registerevent", params);
	}
	/**
	 * registerKbEvent register Keyboard event to watch for
	 *
	 * @param keys Watch the keys
	 * @param modifiers Keyboard modifiers
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int registerKbEvent(String keys, int modifiers) throws LdtpExecutionError {
		Object[] params = new Object[]{keys, modifiers};
		return doAction("registerevent", params);
	}
	/**
	 * deRegisterKbEvent De-Register Keyboard event to watch for
	 *
	 * @param keys Don't watch the keys
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int deRegisterKbEvent(String keys) throws LdtpExecutionError {
		Object[] params = new Object[]{keys};
		return doAction("deregisterevent", params);
	}
	/**
	 * deRegisterKbEvent De-Register Keyboard event to watch for
	 *
	 * @param keys Don't watch the keys
	 * @param modifiers Keyboard modifiers
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int deRegisterKbEvent(String keys, int modifiers) throws LdtpExecutionError {
		Object[] params = new Object[]{keys, modifiers};
		return doAction("deregisterevent", params);
	}
	/**
	 * maximizeWindow Maximize all windows that are currently open
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int maximizeWindow() throws LdtpExecutionError {
		return doAction("maximizewindow", null);
	}
	/**
	 * maximizeWindow Maximize given window that is currently open
	 *
	 * @param windowName Maximize given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int maximizeWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("maximizewindow", params);
	}
	/**
	 * minimizeWindow Minimize all window that are currently open
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int minimizeWindow() throws LdtpExecutionError {
		return doAction("minimizewindow", null);
	}
	/**
	 * minimizeWindow Minimize given window that is currently open
	 *
	 * @param windowName Minimize given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int minimizeWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("minimizewindow", params);
	}
	/**
	 * closeWindow Close all window that are currently open
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int closeWindow() throws LdtpExecutionError {
		return doAction("closewindow", null);
	}
	/**
	 * closeWindow Close given window that is currently open
	 *
	 * @param windowName Close given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int closeWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("closewindow", params);
	}
	/**
	 * unMaximizeWindow Un-maximize all windows
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unMaximizeWindow() throws LdtpExecutionError {
		return doAction("unmaximizewindow", null);
	}
	/**
	 * unMaximizeWindow Un-maximize given window that is currently open
	 *
	 * @param windowName Un-maximize given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unMaximizeWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("unmaximizewindow", params);
	}
	/**
	 * unMinimizeWindow Un-minize all windows
	 *
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unMinimizeWindow() throws LdtpExecutionError {
		return doAction("unminimizewindow", null);
	}
	/**
	 * unMinimizeWindow Un-minize given window
	 *
	 * @param windowName unMinimize given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unMinimizeWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("unminimizewindow", params);
	}
	/**
	 * activateWindow Activate given window that is currently open
	 *
	 * @param windowName Activate given window name
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int activateWindow(String windowName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName};
		return doAction("activatewindow", params);
	}
	/**
	 * appUnderTest Application under test
	 */
	public int appUnderTest(String appName) {
		Object[] params = new Object[]{appName};
		return doAction("appundertest", params);
	}
	/**
	 * getAllStates Get all states of given object
	 *
	 * @return Return String array of states on success
	 * @throws LdtpExecutionError on failure
	 */
	public String[] getAllStates(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getStringList("getallstates", params);
	}
	/**
	 * hasState Verifies whether the object has given state
	 *
	 * @param objName Object name inside the window
	 * @param state State of the object to be verified
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int hasState(String objName, String state) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, state};
		return verifyAction("hasstate", params);
	}
	/**
	 * hasState Verifies whether the object has given state
	 *
	 * @param objName Object name inside the window
	 * @param state State of the object to be verified
	 * @param guiTimeOut Wait for the state till timeout
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int hasState(String objName, String state, int guiTimeOut) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, state, guiTimeOut};
		return verifyAction("hasstate", params);
	}
	/**
	 * grabFocus Grabs focus of given object name
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int grabFocus(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("grabfocus", params);
	}
	/**
	 * click Clicks on the object inside the window
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int click(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("click", params);
	}
	/**
	 * press Press the object
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int press(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("press", params);
	}
	/**
	 * check Check marks the check box
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int check(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("check", params);
	}
	/**
	 * unCheck Un-check check box
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unCheck(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("uncheck", params);
	}
	/**
	 * verifyToggled Verify whether the toggle button is toggled
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyToggled(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifytoggled", params);
	}
	/**
	 * verifyCheck Verify whether the check box is checked
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyCheck(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifycheck", params);
	}
	/**
	 * verifyUnCheck Verify whether the check box is un-checked
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyUnCheck(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyuncheck", params);
	}
	/**
	 * stateEnabled Verify whether the object state is enabled
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success, 0 on failure
	 */
	public int stateEnabled(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("stateenabled", params);
	}
	/**
	 * verifyPushButton Verify whether the given object is push button
	 *
	 * @param objName Object name inside the window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyPushButton(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyPushButton", params);
	}
	/**
	 * getPanelChildCount Get child count of a panel
	 *
	 * @param objName Object name inside the window
	 * @return Return child count on success, -1 on failure
	 */
	public int getPanelChildCount(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return getInt("getpanelchildcount", params);
	}
	/**
	 * selectPanel Select panel by index
	 *
	 * @param objName Object name inside the window
	 * @param index Index in panel
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectPanel(String objName, int index) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, index};
		return doAction("selectpanel", params);
	}
	/**
	 * selectPanelIndex Select panel by index
	 *
	 * @param objName Object name inside the window
	 * @param index Index in panel
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectPanelIndex(String objName, int index) throws LdtpExecutionError {
		return selectPanel(objName, index);
	}
	/**
	 * selectPanelName Select panel by name
	 *
	 * @param objName Object name inside the window
	 * @param name Child name under panel
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectPanelName(String objName, String name) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, name};
		return doAction("selectpanelname", params);
	}
	// Menu
	/**
	 * selectMenuItem Select given menu item
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectMenuItem(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("selectmenuitem", params);
	}
	/**
	 * doesMenuItemExist Verifies whether the given menu item is enabled or not
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success, 0 on failure
	 */
	public int doesMenuItemExist(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("doesmenuitemexist", params);
	}
	/**
	 * listSubMenus Lists all the submenu items
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return sub menus as String array on success
	 * @throws LdtpExecutionError on failure
	 */
	public String[] listSubMenus(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getStringList("listsubmenus", params);
	}
	/**
	 * menuCheck Checks the menuitem
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int menuCheck(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("menucheck", params);
	}
	/**
	 * menuUnCheck Un-checks the menuitem
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int menuUnCheck(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("menuuncheck", params);
	}
	/**
	 * menuItemEnabled Verifies whether the menuitem is enabled
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success, 0 on failure
	 */
	public int menuItemEnabled(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("menuitemenabled", params);
	}
	/**
	 * verifyMenuCheck Verifies whether the menuitem is checked
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyMenuCheck(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifymenucheck", params);
	}
	/**
	 * verifyMenuUnCheck Verifies whether the menuitem is un-checked
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyMenuUnCheck(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifymenuuncheck", params);
	}
	/**
	 * invokeMenu Invokes menu item that are on Linux system tray
	 *
	 * @param objName Object name inside the window, should be ; separated
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int invokeMenu(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("invokemenu", params);
	}
	// Text
	/**
	 * generateKeyEvent Generate keyboard event
	 *
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int generateKeyEvent(String data) throws LdtpExecutionError {
		Object[] params = new Object[]{data};
		return doAction("generatekeyevent", params);
	}
	/**
	 * keyPress Presses keyboard input
	 *
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int keyPress(String data) throws LdtpExecutionError {
		Object[] params = new Object[]{data};
		return doAction("keypress", params);
	}
	/**
	 * keyRelease Releases keyboard input
	 *
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int keyRelease(String data) throws LdtpExecutionError {
		Object[] params = new Object[]{data};
		return doAction("keyrelease", params);
	}
	/**
	 * enterString Generates keyboard input on the current focused window
	 *
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int enterString(String data) throws LdtpExecutionError {
		Object[] params = new Object[]{data};
		return doAction("enterstring", params);
	}
	/**
	 * enterString Generates keyboard input
	 *
	 * @param objName Object name inside the current window
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int enterString(String objName, String data) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, data};
		return doAction("enterstring", params);
	}
	/**
	 * setTextValue Sets text value
	 *
	 * @param objName Object name inside the current window
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setTextValue(String objName, String data) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, data};
		return doAction("settextvalue", params);
	}
	/**
	 * getTextValue Gets text value
	 *
	 * @param objName Object name inside the current window
	 * @return Return data as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getTextValue(String objName) throws LdtpExecutionError {
		return getTextValue(objName, 0, 0);
	}
	/**
	 * getTextValue Gets text value
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position to get the text
	 * @return Return data as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getTextValue(String objName, int startPos) throws LdtpExecutionError {
		return getTextValue(objName, startPos, 0);
	}
	/**
	 * getTextValue Gets text value
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position to get the text
	 * @param endPos End position to get the text
	 * @return Return data as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getTextValue(String objName, int startPos, int endPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, startPos, endPos};
		return getString("gettextvalue", params);
	}
	/**
	 * verifyPartialMatch Verify text with partial string
	 *
	 * @param objName Object name inside the current window
	 * @param data Text to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyPartialMatch(String objName, String data) {
		Object[] params = new Object[]{windowName, objName, data};
		return verifyAction("verifypartialmatch", params);
	}
	/**
	 * verifySetText Verifies complete text is available in the text field
	 *
	 * @param objName Object name inside the current window
	 * @param data Text to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifySetText(String objName, String data) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, data};
		return verifyAction("verifysettext", params);
	}
	/**
	 * activateText Activates text area for focus
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int activateText(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("activatetext", params);
	}
	/**
	 * appendText Appends given text to existing text
	 *
	 * @param objName Object name inside the current window
	 * @param data Input string
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int appendText(String objName, String data) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, data};
		return doAction("appendtext", params);
	}
	/**
	 * isTextStateEnabled Verifies whether text field is enabled or not
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int isTextStateEnabled(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("istextstateenabled", params);
	}
	/**
	 * getCharCount Get character count of a text field
	 *
	 * @param objName Object name inside the current window
	 * @return Return character count as Integer on success
	 * @throws LdtpExecutionError on failure
	 */
	public int getCharCount(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getInt("getcharcount", params);
	}
	/**
	 * setCursorPosition Moves the cursor position
	 *
	 * @param objName Object name inside the current window
	 * @param cursorPos New cursor position
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setCursorPosition(String objName, int cursorPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, cursorPos};
		return doAction("setcursorposition", params);
	}
	/**
	 * getCursorPosition Gets the current cursor position
	 *
	 * @param objName Object name inside the current window
	 * @return Return cursor position as Integer value on success, -1 on failure
	 */
	public int getCursorPosition(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return getInt("getcursorposition", params);
	}
	/**
	 * cutText Cut the text and copy to clipboard
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to cut the text
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int cutText(String objName, int startPos) throws LdtpExecutionError {
		return cutText(objName, startPos, -1);
	}
	/**
	 * cutText Cut the text and copy to clipboard
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to cut the text
	 * @param endPos End position of text to be cut
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int cutText(String objName, int startPos, int endPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, startPos, endPos};
		return doAction("cuttext", params);
	}
	/**
	 * copyText Copy the text to clipboard
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to copy the text
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int copyText(String objName, int startPos) throws LdtpExecutionError {
		return copyText(objName, startPos, -1);
	}
	/**
	 * copyText Copy the text to clipboard
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to copy the text
	 * @param endPos End position to which the text has to be copied
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int copyText(String objName, int startPos, int endPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, startPos, endPos};
		return doAction("copytext", params);
	}
	/**
	 * deleteText Delete the text
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to delete the text
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int deleteText(String objName, int startPos) throws LdtpExecutionError {
		return deleteText(objName, startPos, -1);
	}
	/**
	 * deleteText Delete the text
	 *
	 * @param objName Object name inside the current window
	 * @param startPos Start position from where to delete the text
	 * @param endPos End position to which the text has to be deleted
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int deleteText(String objName, int startPos, int endPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, startPos, endPos};
		return doAction("deletetext", params);
	}
	/**
	 * pasteText Paste the text from clipboard
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int pasteText(String objName) throws LdtpExecutionError {
		return pasteText(objName, 0);
	}
	/**
	 * pasteText Paste the text from clipboard
	 *
	 * @param objName Object name inside the current window
	 * @param cursorPos Cursor position in which the text has to be pasted
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int pasteText(String objName, int cursorPos) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, cursorPos};
		return doAction("pastetext", params);
	}
	/**
	 * pasteText Paste the text from clipboard
	 *
	 * @param objName Object name inside the current window
	 * @return Return status bar text as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getStatusBarText(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getString("getstatusbartext", params);
	}
	// Combo box
	/**
	 * unSelectItem Unselect item in combo box
	 *
	 * @param objName Object name inside the current window
	 * @param itemName item name to be unselected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unSelectItem(String objName, String itemName) {
		Object[] params = new Object[]{windowName, objName, itemName};
		return doAction("unselectitem", params);
	}
	/**
	 * selectItem Select item in combo box
	 *
	 * @param objName Object name inside the current window
	 * @param itemName item name to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectItem(String objName, String itemName) {
		Object[] params = new Object[]{windowName, objName, itemName};
		return doAction("selectitem", params);
	}
	/**
	 * comboSelect Select item in combo box
	 *
	 * @param objName Object name inside the current window
	 * @param itemName item name to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int comboSelect(String objName, String itemName) throws LdtpExecutionError {
		return selectItem(objName, itemName);
	}
	/**
	 * isChildSelected Is child selected in combobox
	 *
	 * @param objName Object name inside the current window
	 * @param itemName item name to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int isChildSelected(String objName, String itemName) {
		Object[] params = new Object[]{windowName, objName, itemName};
		return verifyAction("ischildselected", params);
	}
	/**
	 * verifySelect Verify text is selected in combobox
	 *
	 * @param objName Object name inside the current window
	 * @param itemName item name to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifySelect(String objName, String itemName) {
		Object[] params = new Object[]{windowName, objName, itemName};
		return verifyAction("verifyselect", params);
	}
	/**
	 * isChildIndexSelected Is child index selected in combobox
	 *
	 * @param objName Object name inside the current window
	 * @param itemIndex item index to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int isChildIndexSelected(String objName, int itemIndex) {
		Object[] params = new Object[]{windowName, objName, itemIndex};
		return verifyAction("ischildindexselected", params);
	}
	/**
	 * unSelectIndex Unselect given index from the combo box selection list
	 *
	 * @param objName Object name inside the current window
	 * @param itemIndex item index to be unselected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unSelectIndex(String objName, int itemIndex) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, itemIndex};
		return doAction("unselectindex", params);
	}
	/**
	 * selectIndex Select given index in the combo box
	 *
	 * @param objName Object name inside the current window
	 * @param itemIndex item index to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectIndex(String objName, int itemIndex) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, itemIndex};
		return doAction("selectindex", params);
	}
	/**
	 * comboSelectIndex Select given index in the combo box
	 *
	 * @param objName Object name inside the current window
	 * @param itemIndex item index to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int comboSelectIndex(String objName, int itemIndex) throws LdtpExecutionError {
		return selectIndex(objName, itemIndex);
	}
	/**
	 * selectedItemCount Get number of items selected in combo box
	 *
	 * @param objName Object name inside the current window
	 * @return Return number of items selected on success, -1 on failure
	 */
	public int selectedItemCount(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return doAction("selecteditemcount", params);
	}
	/**
	 * getComboValue Get combobox value
	 *
	 * @param objName Object name inside the current window
	 * @return Return combobox value on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getComboValue(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getString("getcombovalue", params);
	}
	/**
	 * showList Show combo box entries
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int showList(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("showlist", params);
	}
	/**
	 * hideList Hide combo box entries
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int hideList(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("hidelist", params);
	}
	/**
	 * verifyDropDown Verify drop down is shown
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyDropDown(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifydropdown", params);
	}
	/**
	 * verifyShowList Verify combo box list is displayed
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyShowList(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyshowlist", params);
	}
	/**
	 * verifyHideList Verify combo box list is closed
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyHideList(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyhidelist", params);
	}
	/**
	 * getAllItem Gets all item from combo box
	 *
	 * @param objName Object name inside the current window
	 * @return Return String array on success
	 * @throws LdtpExecutionError on failure
	 */
	public String[] getAllItem(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getStringList("getallitem", params);
	}
	/**
	 * selectAll Select all the item in combo box
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectAll(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return doAction("selectall", params);
	}
	/**
	 * unSelectAll Un-select all the item in combo box
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unSelectAll(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return doAction("unselectall", params);
	}
	// Mouse
	/**
	 * generateMouseEvent Generate mouse event
	 *
	 * @param x X co-ordinate
	 * @param y Y co-ordinate
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int generateMouseEvent(int x, int y) throws LdtpExecutionError {
		return generateMouseEvent(x, y, "b1p");
	}
	/**
	 * generateMouseEvent Generate mouse event
	 *
	 * @param x X co-ordinate
	 * @param y Y co-ordinate
	 * @param eventType Event type to be generated
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int generateMouseEvent(int x, int y, String eventType) {
		Object[] params = new Object[]{x, y, eventType};
		return doAction("generatemouseevent", params);
	}
	/**
	 * mouseLeftClick Generate mouse left click on the object
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int mouseLeftClick(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("mouseleftclick", params);
	}
	/**
	 * doubleClick Generate double click on the object
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int doubleClick(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("doubleclick", params);
	}
	/**
	 * mouseMove Move mouse to the object
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int mouseMove(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return doAction("mousemove", params);
	}
	/**
	 * mouseRightClick Generate mouse right click on the object
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int mouseRightClick(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return doAction("mouserightclick", params);
	}
	/**
	 * simulateMouseMove Simulate mouse move from source to destination
	 *
	 * @param source_x Source X co-ordinate
	 * @param source_y Source Y co-ordinate
	 * @param dest_x Destination X co-ordinate
	 * @param dest_y Destination Y co-ordinate
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int simulateMouseMove(int source_x, int source_y, int dest_x, int dest_y) {
		return simulateMouseMove(source_x, source_y, dest_x, dest_y, 0.0);
	}
	/**
	 * simulateMouseMove Simulate mouse move from source to destination
	 *
	 * @param source_x Source X co-ordinate
	 * @param source_y Source Y co-ordinate
	 * @param dest_x Destination X co-ordinate
	 * @param dest_y Destination Y co-ordinate
	 * @param delay Delay between each pixel move in seconds
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int simulateMouseMove(int source_x, int source_y, int dest_x, int dest_y, double delay) {
		Object[] params = new Object[]{source_x, source_y, dest_x, dest_y, delay};
		return doAction("simulatemousemove", params);
	}
	// Page tab
	/**
	 * selectTab Select tab based on the given name
	 *
	 * @param objName Object name inside the current window
	 * @param tabName Tab name to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectTab(String objName, String tabName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, tabName};
		return doAction("selecttab", params);
	}
	/**
	 * selectTabIndex Select tab based on the given index
	 *
	 * @param objName Object name inside the current window
	 * @param tabIndex Tab index to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectTabIndex(String objName, int tabIndex) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, tabIndex};
		return doAction("selecttabindex", params);
	}
	/**
	 * getTabCount Get number of tabs currently opened
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int getTabCount(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("gettabcount", params);
	}
	/**
	 * getTabName Get tab name based on given index
	 *
	 * @param objName Object name inside the current window
	 * @param tabIndex Tab index to get
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getTabName(String objName, int tabIndex) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, tabIndex};
		return getString("gettabname", params);
	}
	/**
	 * verifyTabName Verify tab name is correct
	 *
	 * @param objName Object name inside the current window
	 * @param tabName Tab name to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyTabName(String objName, String tabName) {
		Object[] params = new Object[]{windowName, objName, tabName};
		return verifyAction("verifytabname", params);
	}
	// Table
	/**
	 * getRowCount Get table cell row count
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int getRowCount(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("getrowcount", params);
	}
	/**
	 * selectRow Select table cell with row text matching
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectRow(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText, false};
		return doAction("selectrow", params);
	}
	/**
	 * multiSelect Select multiple table cell with row text matching
	 *
	 * @param objName Object name inside the current window
	 * @param rowTexts Row texts to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int multiSelect(String objName, String []rowTexts) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowTexts, false};
		return doAction("multiselect", params);
	}
	/**
	 * multiRemove Remove multiple table cell with row text matching
	 *
	 * @param objName Object name inside the current window
	 * @param rowTexts Row texts to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int multiRemove(String objName, String []rowTexts) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowTexts, false};
		return doAction("multiremove", params);
	}
	/**
	 * selectRowPartialMatch Select table cell with partial row text matching
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectRowPartialMatch(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText};
		return doAction("selectrowpartialmatch", params);
	}
	/**
	 * selectRowIndex Select table cell based on index
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be selected
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectRowIndex(String objName, int rowIndex) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex};
		return doAction("selectrowindex", params);
	}
	/**
	 * selectLastRow Select last table cell in the table
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int selectLastRow(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("selectlastrow", params);
	}
	/**
	 * setCellValue Set cell value with the given data on row index
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be set
	 * @param data Data to be set
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setCellValue(String objName, int rowIndex, String data) throws LdtpExecutionError {
		return setCellValue(objName, rowIndex, 0, data);
	}
	/**
	 * setCellValue Set cell value with the given data on row index and column
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be set
	 * @param column Column in which data has to be set
	 * @param data Data to be set
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setCellValue(String objName, int rowIndex, int column, String data) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column, data};
		return doAction("setcellvalue", params);
	}
	/**
	 * getCellValue Gets cell value from row index and column 0
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be get
	 * @return Return data from cell as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getCellValue(String objName, int rowIndex) throws LdtpExecutionError {
		return getCellValue(objName, rowIndex, 0);
	}
	/**
	 * getCellValue Gets cell value from row index and column
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be get
	 * @param column Column in which data has to be get
	 * @return Return data from cell as String on success
	 * @throws LdtpExecutionError on failure
	 */
	public String getCellValue(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return getString("getcellvalue", params);
	}
	/**
	 * getCellSize Gets cell size from row index and column 0
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be get
	 * @return Return size of cell as Integer array on success
	 * @throws LdtpExecutionError on failure
	 */
	public Integer[] getCellSize(String objName, int rowIndex) throws LdtpExecutionError {
		return getCellSize(objName, rowIndex, 0);
	}
	/**
	 * getCellSize Gets cell value from row index and column
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index in which data has to be get
	 * @param column Column in which data has to be get
	 * @return Return size of cell as Integer array on success
	 * @throws LdtpExecutionError on failure
	 */
	public Integer[] getCellSize(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return getIntList("getcellsize", params);
	}
	/**
	 * rightClick Right click on table cell with matching row text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int rightClick(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText};
		return doAction("rightclick", params);
	}
	/**
	 * doubleClickRow Double click on table cell with matching row text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to be matched
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int doubleClickRow(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText};
		return doAction("doubleclickrow", params);
	}
	/**
	 * doubleClickRowIndex Double click on table cell with matching row text
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be clicked
	 * @param column Column index to be clicked
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int doubleClickRow(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return doAction("doubleclickrowindex", params);
	}
	/**
	 * checkRow Checkbox the table cell based on row index and column 0
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be checked
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int checkRow(String objName, int rowIndex) throws LdtpExecutionError {
		return checkRow(objName, rowIndex, 0);
	}
	/**
	 * checkRow Checkbox the table cell based on row index
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be checked
	 * @param column Column index to be checked
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int checkRow(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return doAction("checkrow", params);
	}
	/**
	 * expandTableCell Expand table cell based on row index and column 0
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be expanded
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int expandTableCell(String objName, int rowIndex) throws LdtpExecutionError {
		return expandTableCell(objName, rowIndex, 0);
	}
	/**
	 * expandTableCell Expand table cell based on row index and column
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be expanded
	 * @param column Column index to be expanded
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int expandTableCell(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return doAction("expandtablecell", params);
	}
	/**
	 * unCheckRow Un-Checkbox the table cell based on row index and column 0
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be checked
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unCheckRow(String objName, int rowIndex) throws LdtpExecutionError {
		return unCheckRow(objName, rowIndex, 0);
	}
	/**
	 * unCheckRow Un-Checkbox the table cell based on row index and column
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be checked
	 * @param column Column index to be checked
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int unCheckRow(String objName, int rowIndex, int column) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowIndex, column};
		return doAction("uncheckrow", params);
	}
	/**
	 * getTableRowIndex Get table row index based on row text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to search for
	 * @return Return row index as Integer on success
	 * @throws LdtpExecutionError on failure
	 */
	public int getTableRowIndex(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText};
		return getInt("gettablerowindex", params);
	}
	/**
	 * singleClickRow Single click on table cell row based on row text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to search for
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int singleClickRow(String objName, String rowText) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, rowText};
		return getInt("singleclickrow", params);
	}
	/**
	 * verifyTableCell Verify table cell text
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be verified
	 * @param column Column index to be verified
	 * @param rowText Row text to search for
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyTableCell(String objName, int rowIndex, int column, String rowText) {
		Object[] params = new Object[]{windowName, objName, rowIndex, column, rowText};
		return verifyAction("verifytablecell", params);
	}
	/**
	 * doesRowExist Check whether a row exist with the given text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to search for
	 * @return Return 1 on success, 0 on failure
	 */
	public int doesRowExist(String objName, String rowText) {
		return doesRowExist(objName, rowText, false);
	}
	/**
	 * doesRowExist Check whether a row exist with the given partial text
	 *
	 * @param objName Object name inside the current window
	 * @param rowText Row text to search for
	 * @param partialMatch Verify partial match
	 * @return Return 1 on success, 0 on failure
	 */
	public int doesRowExist(String objName, String rowText, Boolean partialMatch) {
		Object[] params = new Object[]{windowName, objName, rowText, partialMatch};
		return verifyAction("doesrowexist", params);
	}
	/**
	 * verifyPartialTableCell Verify table cell with partial text
	 *
	 * @param objName Object name inside the current window
	 * @param rowIndex Row index to be verified
	 * @param column Column index to be verified
	 * @param rowText Partial row text to search for
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyPartialTableCell(String objName, int rowIndex, int column, String rowText) {
		Object[] params = new Object[]{windowName, objName, rowIndex, column, rowText};
		return verifyAction("verifypartialtablecell", params);
	}
	// Scrollbar / slider
	/**
	 * getValue Get value from spin button
	 *
	 * @param objName Object name inside the current window
	 * @return Return Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getValue(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getcellvalue", params);
	}
	/**
	 * getSliderValue Get value from slider
	 *
	 * @param objName Object name inside the current window
	 * @return Return Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getSliderValue(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getslidervalue", params);
	}
	/**
	 * setValue Set value with given double value
	 *
	 * @param objName Object name inside the current window
	 * @param value to be set
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setValue(String objName, double value) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, value};
		return doAction("setcellvalue", params);
	}
	/**
	 * verifySetValue Verify whether the value set is correct
	 *
	 * @param objName Object name inside the current window
	 * @param rowValue Row value to be verified
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifySetValue(String objName, double rowValue) {
		Object[] params = new Object[]{windowName, objName, rowValue};
		return verifyAction("verifysetvalue", params);
	}
	/**
	 * getMinValue Get minimum slider value
	 *
	 * @param objName Object name inside the current window
	 * @return Return minimum Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getMinValue(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getminvalue", params);
	}
	/**
	 * getMaxValue Get maximum slider value
	 *
	 * @param objName Object name inside the current window
	 * @return Return maximum Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getMaxValue(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getmaxvalue", params);
	}
	/**
	 * getMax Get maximum spin button value
	 *
	 * @param objName Object name inside the current window
	 * @return Return maximum Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getMax(String objName) throws LdtpExecutionError {
		return getMaxValue(objName);
	}
	/**
	 * getMinIncrement Get minimum increment value
	 *
	 * @param objName Object name inside the current window
	 * @return Return minimum increment Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getMinIncrement(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getminincrement", params);
	}
	/**
	 * getMaxIncrement Get maximum increment value
	 *
	 * @param objName Object name inside the current window
	 * @return Return maximum increment Double value on success
	 * @throws LdtpExecutionError on failure
	 */
	public double getMaxIncrement(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return getDouble("getmaxincrement", params);
	}
	/**
	 * verifySliderVertical Verify slider is vertical
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifySliderVertical(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyslidervertical", params);
	}
	/**
	 * verifySliderHorizontal Verify slider is horizontal
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifySliderHorizontal(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifysliderhorizontal", params);
	}
	/**
	 * verifyScrollbar Verify scrollbar exist or not
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyScrollbar(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyscrollbar", params);
	}
	/**
	 * verifyScrollbarVertical Verify scrollbar is vertical
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyScrollbarVertical(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyscrollbarvertical", params);
	}
	/**
	 * verifyScrollbarHorizontal Verify scrollbar is horizontal
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success, 0 on failure
	 */
	public int verifyScrollbarHorizontal(String objName) {
		Object[] params = new Object[]{windowName, objName};
		return verifyAction("verifyscrollbarhorizontal", params);
	}
	/**
	 * scrollUp Scroll up once
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int scrollUp(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("scrollup", params);
	}
	/**
	 * scrollDown Scroll down once
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int scrollDown(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("scrolldown", params);
	}
	/**
	 * scrollRight Scroll right once
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int scrollRight(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("scrollright", params);
	}
	/**
	 * scrollLeft Scroll left once
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int scrollLeft(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("scrollleft", params);
	}
	/**
	 * setMax Set maximum value in spin button
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setMax(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("setmax", params);
	}
	/**
	 * setMin Set minimum value in spin button
	 *
	 * @param objName Object name inside the current window
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int setMin(String objName) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName};
		return doAction("setmin", params);
	}
	/**
	 * increase Increase slider value with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int increase(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("increase", params);
	}
	/**
	 * decrease Decrease slider value with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int decrease(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("decrease", params);
	}
	/**
	 * oneUp Up scrollbar with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int oneUp(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("oneup", params);
	}
	/**
	 * oneDown Down scrollbar with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int oneDown(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("onedown", params);
	}
	/**
	 * oneRight Right scrollbar with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int oneRight(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("oneright", params);
	}
	/**
	 * oneLeft Left scrollbar with given iterations
	 *
	 * @param objName Object name inside the current window
	 * @param iterations Repeat the action number of times
	 * @return Return 1 on success
	 * @throws LdtpExecutionError on failure
	 */
	public int oneLeft(String objName, int iterations) throws LdtpExecutionError {
		Object[] params = new Object[]{windowName, objName, iterations};
		return doAction("oneleft", params);
	}
	// Image
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param y Y co-ordinate from where to start capturing image
	 * @param width Width co-ordinate to end capturing image
	 * @param height Height co-ordinate to end capturing image
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(int y, int width, int height) throws LdtpExecutionError {
		return imageCapture("", 0, y, width, height);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param width Width co-ordinate to end capturing image
	 * @param height Height co-ordinate to end capturing image
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(int width, int height) throws LdtpExecutionError {
		return imageCapture("", 0, 0, width, height);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param height Height co-ordinate to end capturing image
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(int height) throws LdtpExecutionError {
		return imageCapture("", 0, 0, -1, height);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture() throws LdtpExecutionError {
		return imageCapture("", 0, 0, -1, -1);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param x X co-ordinate from where to start capturing image
	 * @param y Y co-ordinate from where to start capturing image
	 * @param width Width co-ordinate to end capturing image
	 * @param height Height co-ordinate to end capturing image
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(int x, int y, int width, int height) throws LdtpExecutionError {
		return imageCapture("", x, y, width, height);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param windowName Capture only the window name rather than the complete desktop
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(String windowName) throws LdtpExecutionError {
		return imageCapture(windowName, 0, 0, -1, -1);
	}
	/**
	 * imageCapture Capture screenshot
	 *
	 * @param windowName Capture only the window name rather than the complete desktop
	 * @param x X co-ordinate from where to start capturing image
	 * @param y Y co-ordinate from where to start capturing image
	 * @param width Width co-ordinate to end capturing image
	 * @param height Height co-ordinate to end capturing image
	 * @return Return filename where the captured image is stored on success
	 * @throws LdtpExecutionError on failure
	 */
	public String imageCapture(String windowName, int x, int y, int width, int height) throws LdtpExecutionError {
		String data;
		Object[] params = new Object[]{windowName, x, y, width, height};
		String filename = null;
		try {
			java.io.File f = java.io.File.createTempFile("ldtp_", ".png");
			filename = f.getAbsolutePath();
			f.delete();
			data = getString("imagecapture", params);
			FileOutputStream fp = new FileOutputStream(filename);
			fp.write(Base64.decodeBase64(data));
			fp.close();
		} catch (java.io.FileNotFoundException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		} catch (java.io.IOException ex) {
			throw new LdtpExecutionError(ex.getMessage());
		}
		return filename;
	}
	public static void main(String[] args) {

		/*
	int i;
	Ldtp ldtp = new Ldtp("*-gedit");
	String[] windowList = ldtp.getWindowList();
	for(i = 0; i < windowList.length; i++)
	    System.out.print(windowList[i]);
	System.out.println("");
	String[] appList = ldtp.getAppList();
	for(i = 0; i < appList.length; i++)
	    System.out.print(appList[i]);
	System.out.println("");
	String[] objList = ldtp.getObjectList();
	for(i = 0; i < objList.length; i++)
	    System.out.print(objList[i] + " ");
	System.out.println("");
	try {
	    ldtp.setWindowName("Testing LDTP with Java Client");
	    objList = ldtp.getObjectList();
	    for(i = 0; i < objList.length; i++)
		System.out.print(objList[i] + " ");
	    System.out.println("");
	} catch (LdtpExecutionError ex) {
	    System.out.println(ex.getMessage());
	} finally {
	    ldtp.setWindowName("*-gedit");
	}
	Integer[] size = ldtp.getWindowSize();
	for(i = 0; i < size.length; i++)
	    System.out.print(size[i] + " ");
	System.out.println("");
	size = ldtp.getObjectSize("btnOpen");
	for(i = 0; i < size.length; i++)
	    System.out.print(size[i] + " ");
	System.out.println("");
	System.out.println(ldtp.guiExist());
	System.out.println(ldtp.guiExist("btnOpen"));
	System.out.println(ldtp.objectExist("btnOpen"));
	System.out.println(ldtp.selectMenuItem("mnuFile;mnuNew"));
	try {
	    System.out.println(ldtp.selectMenuItem("mnuFile;mnuDing"));
	} catch (LdtpExecutionError ex) {
	    System.out.println(ex.getMessage());
	}
	System.out.println(ldtp.doesMenuItemExist("mnuFile;mnuNew"));
	System.out.println(ldtp.doesMenuItemExist("mnuFile;mnuDing"));
	String[] subMenus = ldtp.listSubMenus("mnuFile");
	for(i = 0; i < subMenus.length; i++)
	    System.out.print(subMenus[i] + " ");
	System.out.println("");
	System.out.println(ldtp.imageCapture());
	System.out.println(ldtp.launchApp("gnome-terminal"));
	System.out.println(ldtp.waitTillGuiExist());
	ldtp.setWindowName("Testing LDTP with Java Client");
	System.out.println(ldtp.waitTillGuiExist(5));
	ldtp.setWindowName("*-gedit");
	System.out.println(ldtp.getTextValue("txt1"));
	System.out.println(ldtp.click("btnNew"));
		 */
		//Ldtp ldtp = new Ldtp("*Notepad");
		//System.out.println(ldtp.getTextValue("txt0"));
	}
}
